home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Sample Code / Snippets / Networking / Transition Queue Watcher / TransQueue.p < prev   
Encoding:
Text File  |  1993-01-08  |  11.2 KB  |  348 lines  |  [TEXT/MPS ]
  1. UNIT TransQueue;
  2.  
  3. INTERFACE
  4.  
  5. USES MemTypes, QuickDraw, OSIntf, ToolIntf, OSUtils, AppleTalk, ToolUtils;
  6.  
  7. CONST
  8.  
  9. {----------------------------------------------------------------------
  10.         Transition Queue Constants
  11. ----------------------------------------------------------------------}
  12.  
  13. (*  Comment the following 4 constants since they are already defined in the AppleTalk unit 
  14.     ATTransOpen                            =     0;    { .MPP is opening }
  15.     ATTransClose                            =    2;    { .MPP is closing }
  16.     ATTransClosePrep                    =    3;    { OK for .MPP to close? }
  17.     ATTransCancelClose                    =    4;    { .MPP close was cancelled }
  18. *)
  19.     ATTransNetworkTransition        =    5;    { .MPP Network ADEV transition }
  20.     ATTransNameChangeTellTask    =     6;    { Flagship name is changing }
  21.     ATTransNameChangeAskTask    =     7;    { OK to change Flagship name }
  22.     ATTransCancelNameChange        =     8;    { Flagship name change was cancelled }
  23.     ATTransCableChange                    =    'rnge'; { Cable Range Change has occured }
  24.     ATTransSpeedChange                =    'sped'; { Change in processor speed has occured }
  25.  
  26. {----------------------------------------------------------------------
  27.     'STR ' Resource ID'd
  28. ----------------------------------------------------------------------}
  29.     kATTransOpenMsgNum                            = 128;
  30.     kATTransCloseMsgNum                            = 129;
  31.     kATTransClosePrepMsgNum                    = 130;
  32.     kATTransCancelCloseMsgNum                = 131;
  33.     kATTransNetworkTransitionMsgNum        = 132;
  34.     kATTransNameChangeTellTaskMsgNum    = 133;
  35.     kATTransNameChangeAskTaskMsgNum    = 134;
  36.     kATTransCancelNameChangeMsgNum        = 135;
  37.     kATTransCableChangeMsgNum                = 136;
  38.     kATTransSpeedChangeMsgNum                = 137;
  39.     kNewFlagshipNameMsg                            = 138;
  40.     kCancelFlagshipNameMsg                        = 139;
  41.     kLoCableRangeMsg                                = 140;
  42.     kHiCableRangeMsg                                    = 141;
  43.     kNewConnection                                    = 142;
  44.     kCloseConnection                                    = 143;
  45.     kOurAppName                                        = 200;
  46.  
  47.     kNumRecs                                                = 5;    { number of transition records to maintain }
  48.     
  49. {----------------------------------------------------------------------
  50.         NBP Name Change Info record
  51. ----------------------------------------------------------------------}
  52.  
  53. TYPE    
  54.  
  55. NameChangeInfo = RECORD
  56.     newObjStr    : Str32;        { new NBP name }
  57.     name            : Ptr;            { -> to place ptr to name of process that NAK'd the event }
  58.     END;
  59. NameChangePtr = ^NameChangeInfo;
  60. NameChangeHdl = ^NameChangePtr;
  61.  
  62. {----------------------------------------------------------------------
  63.         Network Transition Info Record
  64. ----------------------------------------------------------------------}
  65.  
  66. TNetworkTransition = RECORD
  67.     private        : Ptr;            { pointer to private structure }
  68.     netValidProc    : ProcPtr;    { pointer to network validation procedure }
  69.     newConnectivity : Boolean;    { true = new connection, }
  70.                                     { false = loss of connection }
  71.     END;
  72.  
  73. TNetworkTransitionPtr = ^TNetworkTransition;
  74. TNetworkTransitionHdl = ^TNetworkTransitionPtr;
  75.  
  76. {  The following is the C prototype for the netValidProc function pointer routine     }
  77. {  In the sample ATQ Handler here, the call is implemented through an             }
  78. {  Assembler glue procedure - CallNetValidProc    - declared as an EXTERNAL        }
  79. {  routine.                                                                                                            }
  80. {
  81. typedef pascal long    (*NetworkTransitionProcPtr)(TNetworkTransitionPtr netTrans, \
  82.                       unsigned long theNet);
  83. }
  84. {----------------------------------------------------------------------
  85.         Cable Range Transition Info Record
  86. ----------------------------------------------------------------------}
  87. TNewCRTrans = RECORD
  88.     newCableLo    : INTEGER;    { the new Cable Lo received from RTMP }
  89.     newCableHi    : INTEGER;    { the new Cable Hi received from RTMP }
  90.     END;
  91. TNewCRTransPtr = ^TNewCRTrans;
  92. TNewCRTransHdl = ^TNewCRTransPtr;
  93.  
  94. {
  95.  * The ATQEntry record is defined in the AppleTalk unit, however, the following 
  96.  * definition provides the flexibility to include a pointer to some global data 
  97.  * structure.
  98. }
  99.    
  100. {----------------------------------------------------------------------
  101.         My Transition Event Record Element
  102. ----------------------------------------------------------------------}
  103. IndEventRecord            = RECORD
  104.     evtMsgNum        : INTEGER;
  105.     evtTime            : LONGINT;
  106.     END;
  107.     
  108. TransEventRec = RECORD
  109.     nextFreeEvt        : INTEGER;
  110.     nextEvt2Proc    : INTEGER;
  111.     appNameHandle    : StringHandle;
  112.     oldFlagName        : Str32;
  113.     newFlagName    : Str32;
  114.     newCableLo        : INTEGER;
  115.     newCableHi        : INTEGER;
  116.     allowClose        : Boolean;
  117.     allowChange        : Boolean;
  118.     newConnFlag        : Boolean;
  119.     docTE                : TEHandle;
  120.     indEvtRec            : ARRAY[1..kNumRecs] of IndEventRecord;
  121.     END;
  122. TransEventPtr = ^TransEventRec;
  123. TransEventHdl = ^TransEventPtr;
  124.  
  125. TransEvtPtrArr = ARRAY [1..kNumRecs] of TransEventPtr;
  126.     
  127. {----------------------------------------------------------------------
  128.         AppleTalk Transition Queue Element
  129. ----------------------------------------------------------------------}
  130. myATQEntry = RECORD
  131.     qlink        : Ptr;                        { -> next queue element }
  132.     qType        : INTEGER;            { unused }
  133.     CallAddr     : ProcPtr;            { -> transition procedure }
  134.     globs        : TransEventPtr;    { -> to user defined globals }
  135.     END;
  136. myATQEntryPtr = ^myATQEntry;
  137. myATQEntryHdl = ^myATQEntryPtr;    
  138.  
  139.  
  140. {---------------- Prototypes --------------------}
  141.  
  142. FUNCTION InitTransEventRec(VAR q : TransEventPtr) : OSErr;
  143. {
  144.  *  This function allocates a pointer to the global TransEvent Record.
  145.  }
  146.  
  147.  
  148. FUNCTION ATQueueProc (selector :LONGINT; q :myATQEntryPtr; p : Handle) : LONGINT;
  149. {
  150.  *  Transition queue routines are designed with C calling conventions in mind.
  151.  *  They are passed parameters with a C style stack and return values are expected
  152.  *  to be in register D0.  Note that the CallTransQueue Assembler routine is used
  153.  *  to reverse the C style stack to Pascal style before calling the handler.  The
  154.  *  procedure CallTransQueue follows this listing.  To install the handler, assign 
  155.  *  the address of the CallTransQueue procedure to the ATQEntry.CallAddr field.
  156.  }
  157.   
  158. IMPLEMENTATION
  159.  
  160. FUNCTION GetFlagshipName : Str32;
  161. CONST
  162.     kMachineName    = -16413;
  163.  
  164. VAR
  165.     nameHdl        : StringHandle;
  166.  
  167. BEGIN
  168.     nameHdl := StringHandle (GetResource('STR ', kMachineName));     { get Flagship Name string resource }
  169.     if (nameHdl <> nil) THEN
  170.         GetFlagshipName := nameHdl^^        { if operating under System 7.0 or greater, the string exists. }
  171.     ELSE
  172.         GetFlagshipName := '';                    { otherwise return the empty string.  We won't be processing }
  173.                                                             { Flagship Transition events. }
  174. END;
  175.  
  176. FUNCTION InitTransEventRec(VAR q : TransEventPtr) : OSErr;
  177.  
  178. VAR
  179.     err    : OSErr;
  180.     i        : INTEGER;
  181.     
  182. BEGIN
  183.     err := noErr;                                    { assume no error }
  184.     q := TransEventPtr(NewPtrSys(sizeof(TransEventRec)));  {allocate memory }
  185.     err := MemError;    
  186.     if (err = noErr) THEN
  187.     BEGIN
  188.         q^.appNameHandle := StringHandle(NewHandle(sizeof(Str32)));
  189.         err := MemError;
  190.         if (err = noErr) THEN
  191.         BEGIN
  192.             q^.appNameHandle := StringHandle(GetResource ('STR ', kOurAppName));
  193.             if (q^.appNameHandle = nil) then
  194.                 q^.appNameHandle^^ := 'TransQueueWatcher';    { just in case the resource call failed }
  195.             q^.oldFlagName := GetFlagshipName;
  196.             q^.newFlagName := '';
  197.             q^.newCableLo := 0;
  198.             q^.newCableHi := 0;
  199.             q^.allowClose := TRUE;        { Allow .MPP to close if ATTransClosePrep msg handled }
  200.             q^.allowChange := TRUE;    { Allow Flagship name to be changed if  }
  201.                                                     {    ATTransNameChangeAskTask msg handled }
  202.             q^.newConnFlag := FALSE; 
  203.             q^.docTE := nil;
  204.             q^.nextFreeEvt := 1;
  205.             q^.nextEvt2Proc := 1;
  206.             FOR i := 1 to kNumRecs DO
  207.             BEGIN
  208.                 q^.indEvtRec[i].evtMsgNum := 0;
  209.                 q^.indEvtRec[i].evtTime := 0;
  210.             END;
  211.         END;
  212.     END;
  213.     InitTransEventRec := err;
  214. END;
  215.         
  216. FUNCTION ATQueueProc (selector :LONGINT; q :myATQEntryPtr; p : Handle) : LONGINT;
  217.  
  218. VAR
  219.     returnVal                                : LONGINT;
  220.     myTransEventPtr                    : TransEventPtr;
  221.     myNameChgPtr                        : NameChangePtr;
  222.       myTNewCRTransPtr                : TNewCRTransPtr;
  223.     myTNetworkTransitionPtr    : TNetworkTransitionPtr;
  224.     shortSelector                        : INTEGER;
  225.     checkThisNet                        : LONGINT;
  226.     i                                            : INTEGER;
  227.         
  228.     
  229. BEGIN
  230.     myTransEventPtr := q^.globs;    { get pointer to our trans event record pointer }
  231.     returnVal := 0;
  232.     WITH myTransEventPtr^ DO
  233.     BEGIN
  234.         i := nextFreeEvt;
  235.         GetDateTime(indEvtRec[i].evtTime);            { get event time }
  236.         {
  237.          *    This is the dispatch part of the routine.  We'll check the selector passed into
  238.          *  the task, it's location is 4 bytes off the stack (selector).
  239.          }
  240.         IF ((selector <=8) AND (selector >= 0)) THEN
  241.         {
  242.          *  Check whether a numeric selector is being used whose known values are between
  243.          *  8 and 0 so that we can implement a CASE statement with an INTEGER var.
  244.          }
  245.         BEGIN
  246.             shortSelector := selector;
  247.             CASE shortSelector OF
  248.                 ATTransOpen:
  249.                 BEGIN
  250.                     indEvtRec[i].evtMsgNum := kATTransOpenMsgNum; { .MPP Driver has opened }
  251.                 END;
  252.                     
  253.                 ATTransClose:
  254.                 BEGIN
  255.                     indEvtRec[i].evtMsgNum := kATTransCloseMsgNum; { .MPP Driver closing }
  256.                 END;
  257.                     
  258.                 ATTransClosePrep: 
  259.                 BEGIN
  260.                     indEvtRec[i].evtMsgNum := kATTransClosePrepMsgNum; 
  261.                                                                         { request to allow .MPP Driver to close }
  262.                     if (NOT allowClose) THEN
  263.                     BEGIN
  264.                         returnVal := -1;
  265.                         Ptr(p^) := Ptr(appNameHandle^); { return app name }
  266.                     END;            
  267.                 END;                 
  268.                     
  269.                 ATTransCancelClose:
  270.                 BEGIN
  271.                     indEvtRec[i].evtMsgNum := kATTransCancelCloseMsgNum; 
  272.                                                                         { notification canceling .MPP Driver close }
  273.                 END;
  274.                     
  275.                 ATTransNetworkTransition:
  276.                 BEGIN
  277.                     indEvtRec[i].evtMsgNum := kATTransNetworkTransitionMsgNum; 
  278.                                                                         { Network Transition is occuring }
  279.                     myTNetworkTransitionPtr :=  TNetworkTransitionPtr (p);
  280.     
  281.                     if (myTNetworkTransitionPtr^.newConnectivity) THEN
  282.                         newConnFlag := TRUE
  283.                     ELSE
  284.                         newConnFlag := FALSE;
  285.                         { We could check for network connection here }
  286.                 END;
  287.                     
  288.                 ATTransNameChangeTellTask:
  289.                 BEGIN
  290.                     indEvtRec[i].evtMsgNum := kATTransNameChangeTellTaskMsgNum; 
  291.                                                                         { Flagship Name is changing }
  292.     
  293.                     myNameChgPtr := NameChangePtr (p);        { get the new name }
  294.                     BlockMove(@myNameChgPtr^.newObjStr, @newFlagName, LONGINT(myNameChgPtr^.newObjStr[0]) + 1);
  295.                     BlockMove(@myNameChgPtr^.newObjStr, @oldFlagName, LONGINT(myNameChgPtr^.newObjStr[0]) + 1);
  296.                 END;
  297.                     
  298.                 ATTransNameChangeAskTask:
  299.                 BEGIN
  300.                     indEvtRec[i].evtMsgNum := kATTransNameChangeAskTaskMsgNum; 
  301.                                                                         { OK to change Flagship Name? }
  302.     
  303.                     myNameChgPtr := NameChangePtr (p);        { get the new name }
  304.                     BlockMove(@myNameChgPtr^.newObjStr, @newFlagName, LONGINT(myNameChgPtr^.newObjStr[0]) + 1);
  305.                     if (allowChange = FALSE) THEN
  306.                     BEGIN
  307.                         returnVal := 1;
  308.                         myNameChgPtr^.name := Ptr(appNameHandle); { return app name }
  309.                     END;            
  310.                 END;
  311.                     
  312.                 ATTransCancelNameChange:
  313.                 BEGIN
  314.                     indEvtRec[i].evtMsgNum := kATTransCancelNameChangeMsgNum; 
  315.                                                                         { Flagship Name change has been cancelled }
  316.                 END;
  317.                 
  318.                 OTHERWISE
  319.                     returnVal := 0;
  320.                     {
  321.                      *  Just in case some other numeric selector is implemented.
  322.                      }
  323.             END; { CASE }
  324.         END
  325.         ELSE IF (ResType(selector) = ATTransCableChange) THEN
  326.         BEGIN
  327.             indEvtRec[i].evtMsgNum := kATTransCableChangeMsgNum; 
  328.                                                                 { Cable Range is changing }
  329.     
  330.             myTNewCRTransPtr := TNewCRTransPtr (p);
  331.             newCableLo := myTNewCRTransPtr^.newCableLo;
  332.             newCableHi := myTNewCRTransPtr^.newCableHi;
  333.         END
  334.         ELSE IF (ResType(selector) = ATTransSpeedChange) THEN
  335.         BEGIN
  336.             indEvtRec[i].evtMsgNum := kATTransSpeedChangeMsgNum; 
  337.                                                                 { CPU speed is changing }
  338.         END; { IF }
  339.         
  340.         nextFreeEvt := nextFreeEvt + 1;    { adjust nextFreeEvt to point to next IndEvtRecord }
  341.         IF nextFreeEvt > kNumRecs THEN
  342.             nextFreeEvt := 1;
  343.     END; { WITH myTransEventPtr^ }
  344.  
  345.     ATQueueProc := returnVal;
  346. END;
  347.  
  348. END. { of UNIT }